package Controlador;
import DAO.*;
import Persistencia.*;
import Modelo.*;

import java.util.*;

import com.sun.xml.internal.bind.v2.runtime.unmarshaller.XsiNilLoader.Array;

import DAO.*;

public class Sistema {
	
	private static Sistema instancia;
	private ArrayList<Modelo> modelos;
	private ArrayList<Alquiler> alquileres;
	private ArrayList<Automovil> automoviles;
	private ArrayList<Cliente> clientes;
	private ArrayList<Empleado> empleados;
	private ArrayList<EstrategiaCosto> estrategias;
	private ArrayList<Reserva> reservas;
	private Vector<EstrategiaCosto> descuentos;
	
	
	// Implementa Singletone
	public static Sistema Getinstancia(){
		if (instancia==null){
			instancia=new Sistema();
		}
		return instancia;
	}
	
	private Sistema(){
		this.modelos = new ArrayList<Modelo>();
		this.alquileres = new ArrayList<Alquiler>();
		this.clientes = new ArrayList<Cliente>();
		this.empleados = new ArrayList<Empleado>();
		this.estrategias = new ArrayList<EstrategiaCosto>();
		this.reservas = new ArrayList<Reserva>();
		this.descuentos = new Vector<EstrategiaCosto>();
		this.automoviles = new ArrayList<Automovil>();
		CargarDatosdeIniciales();
		
	}
	
	/// Cargar Datos de Prueba

	private void CargarDatosdeIniciales(){

		// Clientes
		CrearCliente(1, "Barack", "Obama", "12345", "", "", "", "", "", "");
		CrearCliente(2, "Nestor", "Kirchner", "12345", "", "", "", "", "", "");
		CrearCliente(3, "Jacinta", "Pichimahuida", "12345", "", "", "", "", "", "");
		
		// Modelos
		CrearModelo("Ford", "Fiesta", "Polenta", "Frena a veces", ModeloTipo.Auto, 1.00f, 1.00f);
		CrearModelo("Ford", "Ranger", "Bien Polenta", "Airbags", ModeloTipo.Camioneta, 2.00f, 2.00f);
		CrearModelo("Ford", "Transit", "Medio pelo", "Cinturon de seguridad", ModeloTipo.Auto, 3.00f,3.00f);
		// Automoviles
		
		CrearAutomovil("Ford", "Fiesta", "AAA000", 0, CombustibleTipo.Diesel, "Nueva", 2013);
		CrearAutomovil("Ford", "Fiesta", "AAA003", 3541, CombustibleTipo.Diesel, "Nueva", 2007);
		CrearAutomovil("Ford", "Fiesta", "AAA006", 45641, CombustibleTipo.Diesel, "Nueva", 2011);
		
		CrearAutomovil("Ford", "Ranger", "AAA001", 0, CombustibleTipo.GNC, "Nueva", 2013);
		CrearAutomovil("Ford", "Ranger", "AAA004", 1541, CombustibleTipo.GNC, "Nueva", 2001);
		CrearAutomovil("Ford", "Ranger", "AAA007", 13215, CombustibleTipo.GNC, "Nueva", 2010);
		
		CrearAutomovil("Ford", "Transit", "AAA002", 5687, CombustibleTipo.Nafta, "Nueva", 2000);
		CrearAutomovil("Ford", "Transit", "AAA005", 32157, CombustibleTipo.Nafta, "Nueva", 1810);
		CrearAutomovil("Ford", "Transit", "AAA008", 4877, CombustibleTipo.Nafta, "Nueva", 2013);
		this.descuentos = AdministracionPersistenciaDescuento.getInstance().buscarEstrategias();
		this.clientes = AdministracionPersistenciaCliente.getInstance().select();
	}

	//////////////////////////////////////////////	
	/// Metodos de Automovil
	

	public int CrearAutomovil	(
			String modeloMarca,
			String modeloDescripcion,
			String patente,
			int kilometraje,
			CombustibleTipo combustibleTipo,
			String estado,
			int anio) {
		
		// Buscar Modelo, si no existe retorna -1
		Modelo auxModelo = BuscarModelo(modeloMarca, modeloDescripcion);
		if (auxModelo == null)
			return -1;
		
		
		// Verifica que no exista automovil, si existe retorna -2
		Automovil auxAutomovil = BuscarAutomovil(patente);
		if (auxAutomovil == null) {
			// Crear automovil si pudo encontrar modelo
			auxAutomovil = new Automovil(patente, kilometraje, combustibleTipo, "AC", anio, auxModelo);
		}
		else
			return -2;
		
		// si pudo crear el automovil lo agrega a la lista de automoviles
		
		this.automoviles.add(auxAutomovil);
		
		// si termino todo bien devuelvo 0		
		return 0;
		
	}

	// busca un automovil con una patente en la lista, si no lo encuentra devuelve nulo.
	public Automovil BuscarAutomovil(String patente) {
		
		for (Automovil au : this.automoviles) {
			if (au.getPatente().equals(patente)) {
				return au;
			}
		}
		
		return null;
	}

	// Modificar automovil
	// devuelve 0 si finaliza bien
	// devuelve -1 si no encuentra el modelo
	// devuelve -2 si no encuentra el automovil
	// deberiamos cambiarlo para que use excepciones?
	public int ModificarAutomovil(
			String modeloMarca,
			String modeloDescripcion,
			String patente,
			int kilometraje,
			CombustibleTipo combustibleTipo,
			String estado,
			int anio) {
	
	// Buscar Modelo, si no existe retorna -1
	Modelo auxModelo = BuscarModelo(modeloMarca, modeloMarca);
	if (auxModelo == null)
		return -1;
	
	
	// Verifica que exista automovil, si no existe retorna -2
	Automovil auxAutomovil = BuscarAutomovil(patente);
	if (auxAutomovil != null) {
		// Modificar automovil si pudo encontrarlo y el modelo
		
		auxAutomovil.setAnio(anio);
		auxAutomovil.setCombustibleTipo(combustibleTipo);
		auxAutomovil.setKilometraje(kilometraje);
		auxAutomovil.setModelo(auxModelo);
		auxAutomovil.setEstado(estado);
		
	}
	else
		return -2;
	
	this.automoviles.add(auxAutomovil);
	
	// si termino todo bien devuelvo 0		
	return 0;

	}

	// Devuelve una lista de DAO con los datos de los automoviles, para consulta y seleccion
	public ArrayList<DAOAutomovil> ConsultarAutomoviles() {
		
		ArrayList<DAOAutomovil> lista = new ArrayList<DAOAutomovil>();
		for (Automovil au : this.automoviles) {
			
			DAOAutomovil dau = new DAOAutomovil();
			dau.setAnio(au.getAnio());
			dau.setCombustibleTipo(au.getCombustibleTipo().toString());
			dau.setEstado(au.getEstado());
			dau.setKilometraje(au.getKilometraje());
			dau.setModeloDescripcion(au.getModelo().getModelo());
			dau.setModeloMarca(au.getModelo().getMarca());
			dau.setPatente(au.getPatente());
			lista.add(dau);
			
		}
		
		return lista;
		
	}
	
	// Devuelve una lista de DAO con los datos de los automoviles por marca y modelo
	public ArrayList<DAOAutomovil> ConsultarAutomoviles(String marca, String modelo) {
		
		ArrayList<DAOAutomovil> lista = new ArrayList<DAOAutomovil>();
		for (Automovil au : this.automoviles) {
			if (au.getModelo().getMarca().equals(marca) && au.getModelo().getModelo().equals(modelo)) {
		
				DAOAutomovil dau = new DAOAutomovil();
				dau.setAnio(au.getAnio());
				dau.setCombustibleTipo(au.getCombustibleTipo().toString());
				dau.setEstado(au.getEstado());
				dau.setKilometraje(au.getKilometraje());
				dau.setModeloDescripcion(au.getModelo().getModelo());
				dau.setModeloMarca(au.getModelo().getMarca());
				dau.setPatente(au.getPatente());
				
				lista.add(dau);
				
			}
		}
		
		return lista;
		
	}
	
	public void AlquilarAutomovil() {
		
	}
	
	public void DevolverAutomovil() {
		
	}

	//////////////////////////////////////////////
	/// Metodos de Modelos
	
	public int CrearModelo(
			 	String marca,
			    String modelo,
			    String motor,
			    String datosSeguridad,
			    ModeloTipo modeloTipo,
			    float costoAlquilerDia,
			    float costoKmExcedente
			){
		
		// verifico que no exista el modelo
		
		Modelo auxModelo = BuscarModelo(marca, modelo);
		
		// si no existe lo creo
		if (auxModelo == null) {
			auxModelo = new Modelo(marca, modelo, motor, datosSeguridad, modeloTipo, costoAlquilerDia, costoKmExcedente);
			this.modelos.add(auxModelo);
			return 0;
		}
		
		return -1;
		
		
	}
	
	public int ModificarModelo(
			String marca,
		    String modelo,
		    String motor,
		    String datosSeguridad,
		    ModeloTipo modeloTipo,
		    float costoAlquilerDia,
		    float costoKmExcedente)	{
		
		// verifico que no exista el modelo
		
		Modelo auxModelo = BuscarModelo(marca, modelo);
		
		// si no existe error
		
		if (auxModelo == null) 
		{return -1;}
		else // si existe modifico casi todo
		{
			auxModelo.setCostoAlquilerDia(costoAlquilerDia);
			auxModelo.setCostoKmExcedente(costoKmExcedente);
			auxModelo.setDatosSeguridad(datosSeguridad);
			auxModelo.setModeloTipo(modeloTipo);
			auxModelo.setMotor(motor);			
			return 0;
		}
		
		
	}
	
	public int EliminarModelo(String marca, String modelo)	{
		// por ahora esto no hace nada, no deberiamos eliminar modelos
		
		return -1;
		
	}
		
	private Modelo BuscarModelo(String marca, String desc)	{
		
		for (Modelo mod : modelos) {
			if (mod.getMarca().equals(marca) && mod.getModelo().equals(desc)) {
				return mod;
			}
		}
		
		return null;
		
	}
	
	// Obtiene todos los modelos, para combos o pantallas de seleccion
	public ArrayList<DAOModelo> ConsultarModelos(
			){
		
		ArrayList<DAOModelo> lista = new ArrayList<DAOModelo>();
		for (Modelo mo : this.modelos) {
			
			DAOModelo dam = new DAOModelo();
			dam.setModelo(mo.getModelo());
			dam.setMarca(mo.getMarca());
			dam.setDatosSeguridad(mo.getDatosSeguridad());
			dam.setMotor(mo.getMotor());
			dam.setModeloTipo(mo.getModeloTipo().toString());
			dam.setCostoKmExcedente(mo.getCostoKmExcedente());
			dam.setCostoAlquilerDia(mo.getCostoAlquilerDia());
			
			lista.add(dam);
		}
		return lista;
	}

	
	public DAOModelo ConsultarModelo(String marca, String modelo){

		ArrayList<DAOModelo> lista = new ArrayList<DAOModelo>();
		
		for (Modelo mo : this.modelos) {
		
			if (marca.equals(mo.getMarca()) && modelo.equals(mo.getModelo())) {
				DAOModelo dam = new DAOModelo();
				dam.setModelo(mo.getModelo());
				dam.setMarca(mo.getMarca());
				dam.setDatosSeguridad(mo.getDatosSeguridad());
				dam.setMotor(mo.getMotor());
				dam.setModeloTipo(mo.getModeloTipo().toString());
				dam.setCostoKmExcedente(mo.getCostoKmExcedente());
				dam.setCostoAlquilerDia(mo.getCostoAlquilerDia());
				
				return dam;				
			} // end if 
		} // end for

		return null;
	} // end ConsultarModelo
	
	/// Metodos de Costos
	public void CalcularCosto() {
	
	}
	//////////////////////////////////////////////
	// Metodos de Reservas
	

	public int RealizarReserva(
				String patente,
				int dni,
				String desde,
				String hasta
	
	) {
		// Buscar cliente
		
		Cliente cli = this.BuscarCliente(dni);
		if (cli == null) {
			return -1; // no existe el cliente
 		}
		
		// Buscar Automovil
		
		Automovil au = this.BuscarAutomovil(patente);
		if (au == null) {
			return -2; // no existe el automovil
		}
		
		// Validar automovil disponible
		
		// PASO
		
		// Crear Reserva
		
		Reserva re = new Reserva(au, cli, desde, hasta);
		AdministracionPersistenciaReserva.getInstance().insert(re);
		this.reservas.add(re);
		
		return 0;
		
	}
	
	public DAODescuento consultarDescuento (String descripcion){
		DAODescuento descuento = null;

		EstrategiaCosto est = buscarEstrategia(descripcion);
		if (est != null){
			descuento = new DAODescuento(est.getCodigo(), est.getEntidad(), est.getDescuento(),est.getDescripcion(),est.getEstado(), est.getExclusivo(),  est.getPrioridad(), 
					est.getCombinado());				
		}
		
		return descuento;	
		
	}
	
	public EstrategiaCosto buscarEstrategia (String descripcion){
		for (int i = 0; i< descuentos.size(); i++) {
			if (descuentos.elementAt(i).getDescripcion().equals(descripcion)){
				return this.descuentos.elementAt(i);

			}
		}
		
		EstrategiaCosto est = AdministracionPersistenciaDescuento.getInstance().buscarEstrategia(descripcion);
		
		if (est != null){
			descuentos.add(est);
			}
		return est;
	}
	
	public EstrategiaCosto buscarEstrategia (int codigo){
		for (int i = 0; i< descuentos.size(); i++) {
			if (descuentos.elementAt(i).getCodigo()== codigo){
				return this.descuentos.elementAt(i);

			}
		}		
		EstrategiaCosto est = AdministracionPersistenciaDescuento.getInstance().buscarEstrategia(codigo);
		if (est != null){
			descuentos.add(est);
			}
		return est;
	}
	
	public int guardarDescuento (DAODescuento descuento){
		EstrategiaCosto estrategia = buscarEstrategia(descuento.getDescripcion());
		

		if (estrategia == null){
			if (descuento.getDescripcion().equals("porKm")){
				estrategia = new PorKm( descuento.getDescripcion(), descuento.getEstado(),
						descuento.getPrioridad(),descuento.getExclusivo(), descuento.getEntidad(), descuento.getDescuento());
				
			}
			if (descuento.getDescripcion().equals("porDia")){
				estrategia = new PorDia( descuento.getDescripcion(), descuento.getEstado(),
						descuento.getPrioridad(),descuento.getExclusivo(), descuento.getEntidad(), descuento.getDescuento());
				
			}else if (descuento.getCombinado() == 0){
				estrategia = new Descuento( descuento.getDescripcion(), descuento.getEstado(),
						descuento.getPrioridad(),descuento.getExclusivo(), descuento.getEntidad(), descuento.getDescuento());
			} else {
				estrategia = new Combinado(descuento.getDescripcion(), descuento.getEstado(),
						descuento.getPrioridad(),descuento.getExclusivo(), descuento.getEntidad(), new Vector<EstrategiaCosto>());
			}
			descuento.setCodigo(estrategia.getCodigo());
			descuentos.add(estrategia);
			return 0;
			
		} else {
			return actualizarDescuento(estrategia, descuento);
		}
	
	}
	
	public int actualizarDescuento (EstrategiaCosto estrategia, DAODescuento descuento){
		
		estrategia.setDescripcion(descuento.getDescripcion());
		estrategia.setDescuento(descuento.getDescuento());
		estrategia.setEntidad(descuento.getEntidad());
		estrategia.setEstado(descuento.getEstado());
		estrategia.setExclusivo(descuento.getExclusivo());
		estrategia.setPrioridad(descuento.getPrioridad());
	    if (descuento.getCombinado() != estrategia.getCombinado()){
			eliminardescuento(estrategia);
			if (descuento.getCombinado() == 0){
				estrategia = new Descuento(descuento.getCodigo(), descuento.getDescripcion(), descuento.getEstado(),
						descuento.getPrioridad(),descuento.getExclusivo(), descuento.getEntidad(), descuento.getDescuento());
			} else {
				estrategia = new Combinado( descuento.getCodigo(),descuento.getDescripcion(), descuento.getEstado(),
						descuento.getPrioridad(),descuento.getExclusivo(), descuento.getEntidad(), new Vector<EstrategiaCosto>());
			}
			descuentos.add(estrategia);			
		}

			
			
		return 0;
		
		
		
	}
	
	public Vector<DAOCombinaciones> obtenerCombinacionesPosibles (){
		Vector<DAOCombinaciones> combinacionesPosibles = new Vector<DAOCombinaciones> ();
		for (int i = 0; i< descuentos.size();i++){
			if (descuentos.elementAt(i).getExclusivo() == 0){
				DAOCombinaciones combinacion = new DAOCombinaciones(descuentos.elementAt(i).getCodigo(),descuentos.elementAt(i).getDescripcion());
				combinacionesPosibles.add(combinacion);
			}
		}
		return combinacionesPosibles;
	}
	
	public void eliminardescuento (EstrategiaCosto estrategia){
		for (int i = 0; i<descuentos.size(); i++){
			if (estrategia.getCodigo() == descuentos.elementAt(i).getCodigo()){
				descuentos.removeElementAt(i);
			}
		}
	}
	
	public int eliminarCombinacion (int codigo, int codigoCombinado){
		EstrategiaCosto est = buscarEstrategia(codigo);
		if (est != null){
			if (est.getCombinado() == 1){
				Combinado estComb = (Combinado) est;
				for (int i = 0 ; i< estComb.getCombinaciones().size(); i++){
					if (estComb.getCombinaciones().elementAt(i).getCodigo() == codigoCombinado){
						estComb.getCombinaciones().removeElementAt(i);
						estComb.actualizarCombinaciones();
						return 0;
					} else {
							// no existe descuento
							return 1;
						}
										
				}				
			} else {
				// No es combinable
				return 2;
			}
			
		} else {
			//No existe el descuento
			return 3;
		}
		
		return 0;		
		
	}
	public int agregarCombinacion (int codigo, int codigoCombinado){
		EstrategiaCosto est = buscarEstrategia(codigo);
		Combinado estComb = (Combinado) est;
		
		EstrategiaCosto combinado = buscarEstrategia(codigoCombinado);
		estComb.getCombinaciones().add(combinado);
		estComb.actualizarCombinaciones();
		
		return 0;		
		
	}
	
	public float calcularCosto(int kilometraje, int dias, float costoAlquiler, int codigoDescuento){
	float precioAlquiler = 0;
	EstrategiaCosto estrategia= buscarEstrategia(codigoDescuento);
	
	if (estrategia != null){
		precioAlquiler = precioAlquiler * estrategia.calcularDescuento(kilometraje, dias, costoAlquiler)/100;
	}
		
	
	return precioAlquiler;
}
	
	public Vector<DAOCombinaciones> obtenerCombinaciones (int codigo){
	EstrategiaCosto est = AdministracionPersistenciaDescuento.getInstance().buscarEstrategia(codigo);
	Vector<DAOCombinaciones> result = new Vector<DAOCombinaciones>();
	
	if (est.getCombinado() == 1) {
		Combinado comb = (Combinado) est; 
		for (int i = 0; i> comb.getCombinaciones().size();i++){
			DAOCombinaciones combinacion = new DAOCombinaciones(comb.getCombinaciones().elementAt(i).getCodigo(),comb.getCombinaciones().elementAt(i).getDescripcion());
			result.add(combinacion);
		}
	}
	return result;
}
	

	public ArrayList<DAOReserva> ConsultarReservas() {
		ArrayList<DAOReserva> lista = new ArrayList<DAOReserva>();
		
		for (Reserva r : this.reservas) {
			DAOReserva dr = new DAOReserva(
					r.getAutomovil().getModelo().getMarca(),
					r.getAutomovil().getModelo().getModelo(),
					r.getAutomovil().getPatente(), 
					r.getCliente().getDni(), 
					r.getCliente().getNombre(), 
					r.getCliente().getApellido(), 
					r.getDesde(), 
					r.getHasta());
			lista.add(dr);
		}
		return lista;
	}
	
	public void BuscarReserva() {
		
	}
	
	public void ConfirmarReserva(DAOReserva reserva, String comentarios, int codigo) {
		
		Alquiler alq = Alquiler.confirmarReserva(reserva, comentarios, buscarEstrategia(codigo), 100);
		this.alquileres.add(alq);
		
		
	}
	
	//////////////////////////////////////////////	
	/// Metodos de Clientes
	
	public void RegistrarUsuario(	 
					int dni,
					 String nombre,
					 String apellido,
					 String nacimiento,
					 String domicilio,
					 String telefono,
					 String sexo,
					 String nacionalidad,
					 String usuario,
					 String password
						){
		
		// verifico que no exista el usuario del sistema 
		// verifico que el cliente no exista
	
		Cliente auxCli = this.BuscarCliente(usuario);
	
		// inserto el cliente
		
	
		if (auxCli == null) {
			auxCli = new Cliente(dni, nombre, apellido, nacimiento, domicilio, telefono, sexo, nacionalidad, usuario, password, "AC");
			this.clientes.add(auxCli);
			
		}
		
	}
	
	public int CrearCliente(
			int dni, 
			String nom, 
			String ape, 
			String fnac, 
			String dom, 
			String telef, 
			String sexo, 
			String nac,
			String usuario,
			String Password) {
		
		// verifico que el cliente no exista

		Cliente auxCli = this.BuscarCliente(dni);
		

		// inserto el cliente
		

		if (auxCli == null) {
			auxCli = new Cliente(dni, nom, ape, fnac, dom, telef, sexo, nac, usuario, Password, "AC", "PERSISTIR!!!");
			this.clientes.add(auxCli);
			return 0;
		}
		return -1;

		
	}
	
	public ArrayList<DAOCliente> ConsultarClientes() {
		ArrayList<DAOCliente> lista = new ArrayList<DAOCliente>();
		
		for (Cliente cli : this.clientes) {
			DAOCliente dcli = new DAOCliente(cli.getDni(), cli.getNombre(), cli.getApellido(), cli.getNacimiento(), cli.getDomicilio(), cli.getTelefono(), cli.getSexo(), cli.getNacionalidad(), cli.getUsuario(), cli.getPassword(), cli.getEstado());
			lista.add(dcli);
		}
		return lista;
	}

	public DAOCliente ConsultarCliente(Integer dni) {
		
		Cliente cli = BuscarCliente(dni);
		if (cli != null) {
			DAOCliente dcli = new DAOCliente(cli.getDni(), cli.getNombre(), cli.getApellido(), cli.getNacimiento(), cli.getDomicilio(), cli.getTelefono(), cli.getSexo(), cli.getNacionalidad(), cli.getUsuario(), cli.getPassword(), cli.getEstado());
			return dcli;
		}
		else
		{
			return null;
		}
		
	}

	
	public int  EliminarCliente(int dni) {
	
		// deberia buscarlo, verificar que no tenga nada asociado y eliminarlo o marcarlo como eliminado.
		
		for (Cliente cli : clientes) {
			if (cli.getDni() == dni) {
				AdministracionPersistenciaCliente.getInstance().delete(cli);
				
				return 0;
			}
		}
		
		// si no lo encuentra devuelve -1
		return -1;
		
	}
	
	public int ModificarCliente(int dni, String nom, String ape, String fnac, String dom, String telef, String sexo, String nac, String usuario, String clave, String estado) {
		
		for (Cliente cli : clientes) {
			if (cli.getDni() == dni) {
				
				cli.setApellido(ape);
				cli.setDomicilio(dom);
				cli.setEstado(estado);
				cli.setNacimiento(fnac);
				cli.setNacionalidad(nac);
				cli.setNombre(nom);
				cli.setPassword(clave);
				cli.setSexo(sexo);
				cli.setTelefono(telef);
				
				AdministracionPersistenciaCliente.getInstance().update(cli);
			}
		}
		
		// si no lo encuentra devuelve -1
		return -1;
		
	}	

	private Cliente BuscarCliente(int dni)
	{
		for (Cliente cli : this.clientes) {
			if (cli.getDni() == dni) {
				return cli;
			}
		}
		
		return null;
	}

	private Cliente BuscarCliente(String usuario)
	{
		for (Cliente cli : this.clientes) {
			if (cli.getUsuario().equals(usuario)) {
				return cli;
			}
		}
		
		return null;
	}


	/////////////////////////////////////////////
	// Metodos de incidencias
	
	public void RegistrarIncidencia() {
	
	}
	
	/////////////////////////////////////////////
	// Metodos de Costos
	
	public ArrayList<dtoAlquiler> obtenerAlquileres(){
		ArrayList<dtoAlquiler> Ralquileres = new ArrayList<dtoAlquiler>();
		for (Alquiler alquiler : alquileres) {
			dtoAlquiler nAlq = alquiler.getDtoAlquiler();
			Ralquileres.add(nAlq);
		}
		return Ralquileres;
	}
	
	
	public int RealizarAlquiler(
			String patente,
			int dni,
			String desde,
			String hasta
	) {
	// Buscar cliente
	
	Cliente cli = this.BuscarCliente(dni);
	if (cli == null) {
		return -1; // no existe el cliente
		}
	
	// Buscar Automovil
	
	Automovil au = this.BuscarAutomovil(patente);
	if (au == null) {
		return -2; // no existe el automovil
	}
	
	// Validar automovil disponible
	
	// PASO
	
	// Crear el alquiler
	
	
	
	
	
	return 0;
	
}
}
